package com.yuke.cloud.service.smc.entity;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.util.Date;
import javax.persistence.*;

@ApiModel(value="com.yuke.cloud.service.smc.entity.AssGoodsCancel")
@Table(name = "ass_goods_cancel")
public class AssGoodsCancel {
    /**
     * 主键，自增
     */
    @Id
    @Column(name = "goods_cancel_id")
    @ApiModelProperty(value="goodsCancelId主键，自增")
    private Long goodsCancelId;

    /**
     * 关联原单号
     */
    @Column(name = "stock_order_id")
    @ApiModelProperty(value="stockOrderId关联原单号")
    private Long stockOrderId;

    /**
     * 订单号，唯一
     */
    @Column(name = "stock_order_sn")
    @ApiModelProperty(value="stockOrderSn订单号，唯一")
    private String stockOrderSn;

    /**
     * 要取消的商品ID
     */
    @Column(name = "stock_goods_id")
    @ApiModelProperty(value="stockGoodsId要取消的商品ID")
    private Long stockGoodsId;

    /**
     * 店铺ID
     */
    @Column(name = "shop_id")
    @ApiModelProperty(value="shopId店铺ID")
    private Long shopId;

    /**
     * 应退金额，单位为分
     */
    @Column(name = "refund_payable")
    @ApiModelProperty(value="refundPayable应退金额，单位为分")
    private Integer refundPayable;

    /**
     * 已退金额
     */
    @Column(name = "refund_paid")
    @ApiModelProperty(value="refundPaid已退金额")
    private Integer refundPaid;

    /**
     * 取消状态， 0：未取消；1：确认已取消；2：已准备入库，无法取消
     */
    @Column(name = "cancel_status")
    @ApiModelProperty(value="cancelStatus取消状态， 0：未取消；1：确认已取消；2：已准备入库，无法取消")
    private Byte cancelStatus;

    /**
     * 是否已完成退款， 0：未退款；1：已退款
     */
    @Column(name = "is_refund")
    @ApiModelProperty(value="isRefund是否已完成退款， 0：未退款；1：已退款")
    private Boolean isRefund;

    /**
     * 退款方式，  1：原路退回；2：其他
     */
    @Column(name = "refund_type")
    @ApiModelProperty(value="refundType退款方式，  1：原路退回；2：其他")
    private Byte refundType;

    /**
     * 取消原因，  0：其他，1：采购计划已变，2：误采购
     */
    @Column(name = "cancel_reason")
    @ApiModelProperty(value="cancelReason取消原因，  0：其他，1：采购计划已变，2：误采购")
    private Byte cancelReason;

    /**
     * 自定义退货原因
     */
    @Column(name = "custom_cancel_reason")
    @ApiModelProperty(value="customCancelReason自定义退货原因")
    private String customCancelReason;

    /**
     * 是否删除，0：未删除，1：已删除
     */
    @Column(name = "is_delete")
    @ApiModelProperty(value="isDelete是否删除，0：未删除，1：已删除")
    private Boolean isDelete;

    /**
     * 取消申请时间
     */
    @Column(name = "create_time")
    @ApiModelProperty(value="createTime取消申请时间")
    private Date createTime;

    /**
     * 获取主键，自增
     *
     * @return goods_cancel_id - 主键，自增
     */
    public Long getGoodsCancelId() {
        return goodsCancelId;
    }

    /**
     * 设置主键，自增
     *
     * @param goodsCancelId 主键，自增
     */
    public AssGoodsCancel setGoodsCancelId(Long goodsCancelId) {
        this.goodsCancelId = goodsCancelId;
        return this;
    }

    /**
     * 获取关联原单号
     *
     * @return stock_order_id - 关联原单号
     */
    public Long getStockOrderId() {
        return stockOrderId;
    }

    /**
     * 设置关联原单号
     *
     * @param stockOrderId 关联原单号
     */
    public AssGoodsCancel setStockOrderId(Long stockOrderId) {
        this.stockOrderId = stockOrderId;
        return this;
    }

    /**
     * 获取订单号，唯一
     *
     * @return stock_order_sn - 订单号，唯一
     */
    public String getStockOrderSn() {
        return stockOrderSn;
    }

    /**
     * 设置订单号，唯一
     *
     * @param stockOrderSn 订单号，唯一
     */
    public AssGoodsCancel setStockOrderSn(String stockOrderSn) {
        this.stockOrderSn = stockOrderSn;
        return this;
    }

    /**
     * 获取要取消的商品ID
     *
     * @return stock_goods_id - 要取消的商品ID
     */
    public Long getStockGoodsId() {
        return stockGoodsId;
    }

    /**
     * 设置要取消的商品ID
     *
     * @param stockGoodsId 要取消的商品ID
     */
    public AssGoodsCancel setStockGoodsId(Long stockGoodsId) {
        this.stockGoodsId = stockGoodsId;
        return this;
    }

    /**
     * 获取店铺ID
     *
     * @return shop_id - 店铺ID
     */
    public Long getShopId() {
        return shopId;
    }

    /**
     * 设置店铺ID
     *
     * @param shopId 店铺ID
     */
    public AssGoodsCancel setShopId(Long shopId) {
        this.shopId = shopId;
        return this;
    }

    /**
     * 获取应退金额，单位为分
     *
     * @return refund_payable - 应退金额，单位为分
     */
    public Integer getRefundPayable() {
        return refundPayable;
    }

    /**
     * 设置应退金额，单位为分
     *
     * @param refundPayable 应退金额，单位为分
     */
    public AssGoodsCancel setRefundPayable(Integer refundPayable) {
        this.refundPayable = refundPayable;
        return this;
    }

    /**
     * 获取已退金额
     *
     * @return refund_paid - 已退金额
     */
    public Integer getRefundPaid() {
        return refundPaid;
    }

    /**
     * 设置已退金额
     *
     * @param refundPaid 已退金额
     */
    public AssGoodsCancel setRefundPaid(Integer refundPaid) {
        this.refundPaid = refundPaid;
        return this;
    }

    /**
     * 获取取消状态， 0：未取消；1：确认已取消；2：已准备入库，无法取消
     *
     * @return cancel_status - 取消状态， 0：未取消；1：确认已取消；2：已准备入库，无法取消
     */
    public Byte getCancelStatus() {
        return cancelStatus;
    }

    /**
     * 设置取消状态， 0：未取消；1：确认已取消；2：已准备入库，无法取消
     *
     * @param cancelStatus 取消状态， 0：未取消；1：确认已取消；2：已准备入库，无法取消
     */
    public AssGoodsCancel setCancelStatus(Byte cancelStatus) {
        this.cancelStatus = cancelStatus;
        return this;
    }

    /**
     * 获取是否已完成退款， 0：未退款；1：已退款
     *
     * @return is_refund - 是否已完成退款， 0：未退款；1：已退款
     */
    public Boolean getIsRefund() {
        return isRefund;
    }

    /**
     * 设置是否已完成退款， 0：未退款；1：已退款
     *
     * @param isRefund 是否已完成退款， 0：未退款；1：已退款
     */
    public AssGoodsCancel setIsRefund(Boolean isRefund) {
        this.isRefund = isRefund;
        return this;
    }

    /**
     * 获取退款方式，  1：原路退回；2：其他
     *
     * @return refund_type - 退款方式，  1：原路退回；2：其他
     */
    public Byte getRefundType() {
        return refundType;
    }

    /**
     * 设置退款方式，  1：原路退回；2：其他
     *
     * @param refundType 退款方式，  1：原路退回；2：其他
     */
    public AssGoodsCancel setRefundType(Byte refundType) {
        this.refundType = refundType;
        return this;
    }

    /**
     * 获取取消原因，  0：其他，1：采购计划已变，2：误采购
     *
     * @return cancel_reason - 取消原因，  0：其他，1：采购计划已变，2：误采购
     */
    public Byte getCancelReason() {
        return cancelReason;
    }

    /**
     * 设置取消原因，  0：其他，1：采购计划已变，2：误采购
     *
     * @param cancelReason 取消原因，  0：其他，1：采购计划已变，2：误采购
     */
    public AssGoodsCancel setCancelReason(Byte cancelReason) {
        this.cancelReason = cancelReason;
        return this;
    }

    /**
     * 获取自定义退货原因
     *
     * @return custom_cancel_reason - 自定义退货原因
     */
    public String getCustomCancelReason() {
        return customCancelReason;
    }

    /**
     * 设置自定义退货原因
     *
     * @param customCancelReason 自定义退货原因
     */
    public AssGoodsCancel setCustomCancelReason(String customCancelReason) {
        this.customCancelReason = customCancelReason;
        return this;
    }

    /**
     * 获取是否删除，0：未删除，1：已删除
     *
     * @return is_delete - 是否删除，0：未删除，1：已删除
     */
    public Boolean getIsDelete() {
        return isDelete;
    }

    /**
     * 设置是否删除，0：未删除，1：已删除
     *
     * @param isDelete 是否删除，0：未删除，1：已删除
     */
    public AssGoodsCancel setIsDelete(Boolean isDelete) {
        this.isDelete = isDelete;
        return this;
    }

    /**
     * 获取取消申请时间
     *
     * @return create_time - 取消申请时间
     */
    public Date getCreateTime() {
        return createTime;
    }

    /**
     * 设置取消申请时间
     *
     * @param createTime 取消申请时间
     */
    public AssGoodsCancel setCreateTime(Date createTime) {
        this.createTime = createTime;
        return this;
    }
}